C# OOP Concepts: Class, Object, Inheritance, Polymorphism Examples

🎯 1. Class & Object

Basic Definition:
A class is a blueprint or template that defines what an object will be. An object is an actual instance created from that class.

csharp
// CLASS (Blueprint)
class Car
{
    public string color;
    public string model;
    
    public void Honk()
    {
        Console.WriteLine("Beep beep!");
    }
}

// OBJECTS (Actual instances)
Car myCar = new Car();
myCar.color = "Red";
myCar.model = "Toyota";
myCar.Honk();

Car yourCar = new Car();
yourCar.color = "Blue";
yourCar.model = "Honda";
yourCar.Honk();

Explanation:

  • Class is like a cookie cutter - it defines the shape

  • Objects are the actual cookies made from that cutter

  • You can create multiple objects from one class, each with different data

🎁 2. Encapsulation

Basic Definition:
Encapsulation means bundling data and methods together, and restricting direct access to some components to protect data integrity.

csharp
class BankAccount
{
    // Private field - hidden from outside
    private double balance = 0;
    
    // Public method - controlled access
    public void Deposit(double amount)
    {
        if(amount > 0)
        {
            balance += amount;
            Console.WriteLine($"Deposited: ${amount}");
        }
        else
        {
            Console.WriteLine("Invalid amount!");
        }
    }
    
    public void Withdraw(double amount)
    {
        if(amount > 0 && amount <= balance)
        {
            balance -= amount;
            Console.WriteLine($"Withdrawn: ${amount}");
        }
        else
        {
            Console.WriteLine("Insufficient funds!");
        }
    }
    
    public double GetBalance()
    {
        return balance;
    }
}

// Usage
BankAccount account = new BankAccount();
account.Deposit(1000);        // ✅ Allowed - through method
account.Withdraw(200);         // ✅ Allowed - through method
Console.WriteLine(account.GetBalance()); // ✅ Allowed - through method

// account.balance = 5000;    // ❌ NOT allowed - direct access prevented
// account.balance = -100;    // ❌ NOT allowed - prevents invalid data

Explanation:

  • Private fields (balance) are hidden like money in a safe

  • Public methods are like bank tellers - they control access

  • Prevents invalid operations (negative deposits, over-withdrawals)

  • The internal implementation can change without affecting users

👨‍👦 3. Inheritance

Basic Definition:
Inheritance allows a new class to acquire properties and behaviors of an existing class, promoting code reuse.

csharp
// PARENT CLASS (Base class)
class Animal
{
    public string Name;
    
    public void Eat()
    {
        Console.WriteLine($"{Name} is eating...");
    }
    
    public void Sleep()
    {
        Console.WriteLine($"{Name} is sleeping...");
    }
}

// CHILD CLASSES (Derived classes) - Inherit from Animal
class Dog : Animal  // Dog inherits from Animal
{
    public void Bark()
    {
        Console.WriteLine($"{Name} says: Woof woof!");
    }
}

class Cat : Animal  // Cat inherits from Animal
{
    public void Meow()
    {
        Console.WriteLine($"{Name} says: Meow!");
    }
}

// Usage
Dog myDog = new Dog();
myDog.Name = "Buddy";
myDog.Eat();    // Inherited from Animal
myDog.Sleep();  // Inherited from Animal  
myDog.Bark();   // Its own method

Cat myCat = new Cat();
myCat.Name = "Whiskers";
myCat.Eat();    // Inherited from Animal
myCat.Sleep();  // Inherited from Animal
myCat.Meow();   // Its own method

Explanation:

  • Parent class contains common features (eat, sleep)

  • Child classes get all parent features automatically

  • Each child can add its own special features (bark, meow)

  • Avoids code duplication - write once, use everywhere

🎭 4. Polymorphism

Basic Definition:
Polymorphism means "many forms" - the same method or property can behave differently in different classes.

csharp
class Shape
{
    public virtual void Draw()  // Virtual = can be overridden
    {
        Console.WriteLine("Drawing a shape");
    }
}

class Circle : Shape
{
    public override void Draw()  // Override = provide new behavior
    {
        Console.WriteLine("Drawing a circle ⭕");
    }
}

class Square : Shape
{
    public override void Draw()  // Override = provide new behavior
    {
        Console.WriteLine("Drawing a square ◼️");
    }
}

class Triangle : Shape
{
    public override void Draw()  // Override = provide new behavior
    {
        Console.WriteLine("Drawing a triangle 🔺");
    }
}

// Usage
Shape[] shapes = new Shape[3];  // Array of base type
shapes[0] = new Circle();       // But holds different types
shapes[1] = new Square();
shapes[2] = new Triangle();

foreach (Shape shape in shapes)
{
    shape.Draw();  // Same method, different behaviors!
}
// Output:
// Drawing a circle ⭕
// Drawing a square ◼️  
// Drawing a triangle 🔺

Explanation:

  • Same method name (Draw) but different implementations

  • Virtual in parent = "child classes can change this"

  • Override in child = "I'm providing my own version"

  • Useful when you want to treat different objects the same way

🔍 5. Abstraction

Basic Definition:
Abstraction means showing only essential features and hiding the complex implementation details.

csharp
// Abstract class - cannot create objects directly
abstract class Vehicle
{
    public string Model { get; set; }
    
    // Abstract method - no implementation, must be overridden
    public abstract void Start();
    
    // Concrete method - has implementation
    public void Stop()
    {
        Console.WriteLine($"{Model} has stopped");
    }
}

class Car : Vehicle
{
    public override void Start()  // Must implement abstract method
    {
        Console.WriteLine($"{Model} car: Turn key to start");
    }
}

class Bike : Vehicle
{
    public override void Start()  // Must implement abstract method  
    {
        Console.WriteLine($"{Model} bike: Kick start");
    }
}

// Usage
Vehicle myCar = new Car { Model = "Toyota" };
Vehicle myBike = new Bike { Model = "Yamaha" };

myCar.Start();  // "Toyota car: Turn key to start"
myCar.Stop();   // "Toyota has stopped"

myBike.Start(); // "Yamaha bike: Kick start"  
myBike.Stop();  // "Yamaha has stopped"

// Vehicle v = new Vehicle();  // ❌ ERROR - cannot create abstract class

Explanation:

  • Abstract class = incomplete blueprint, cannot create objects

  • Abstract methods = "must do this" without saying how

  • Concrete methods = "already done, you can use as-is"

  • Forces child classes to provide their own implementations

📜 6. Interface

Basic Definition:
An interface defines a contract that classes must follow - it specifies what methods/properties must be implemented, but not how.

csharp
// INTERFACES (Contracts)
interface IFlyable
{
    void Fly();  // No implementation, just signature
}

interface ISwimmable  
{
    void Swim();
}

// CLASSES implementing interfaces
class Bird : IFlyable
{
    public void Fly()  // Must implement Fly() method
    {
        Console.WriteLine("Bird is flying by flapping wings 🕊️");
    }
}

class Airplane : IFlyable  
{
    public void Fly()  // Must implement Fly() method
    {
        Console.WriteLine("Airplane is flying using jet engines ✈️");
    }
}

class Duck : IFlyable, ISwimmable  // Can implement multiple interfaces
{
    public void Fly()
    {
        Console.WriteLine("Duck is flying short distances 🦆");
    }
    
    public void Swim()  
    {
        Console.WriteLine("Duck is swimming in water 🏊");
    }
}

// Usage
IFlyable[] flyingThings = new IFlyable[3];
flyingThings[0] = new Bird();
flyingThings[1] = new Airplane();  
flyingThings[2] = new Duck();

foreach (IFlyable item in flyingThings)
{
    item.Fly();  // All can fly, but differently
}

Explanation:

  • Interface = contract saying "you must have these methods"

  • No implementation in interface, only method signatures

  • Classes promise to implement all interface methods

  • Multiple interfaces allowed (unlike single inheritance)

  • Enables different classes to be used interchangeably

🎯 Key Differences Summary:

ConceptSimple MeaningReal-world Example
Class & ObjectBlueprint vs Actual thingCookie cutter vs Cookies
EncapsulationData protectionATM machine controlling cash access
InheritanceParent-child relationshipFamily traits passed down
PolymorphismSame action, different resultsPower button (TV vs Computer)
AbstractionHide complexityCar dashboard hiding engine
InterfaceContract or capability"Can fly" contract for birds/planes

 

Comments

Post a Comment

Popular posts from this blog

.NET Core Interview Questions and Answers for 10+ Years Experienced Professionals

  🔹 Core Concepts Q1. What are the key differences between .NET Framework, .NET Core, and .NET 5/6/7+? Answer: .NET Framework – Windows-only, older, supports legacy apps. .NET Core – Cross-platform (Windows, Linux, macOS), modular, open-source, better performance. .NET 5+ (unified platform) – Combines .NET Core and .NET Framework into one platform with continuous updates (no ".NET Core 4"). Q2. Explain the Middleware pipeline in ASP.NET Core. Answer: Middleware is a software component that processes HTTP requests and responses. It forms a pipeline where each component can handle, pass, or short-circuit a request. Example: app.UseRouting(); app.UseAuthentication(); app.UseAuthorization(); app.UseEndpoints(endpoints => { endpoints.MapControllers(); }); Custom middleware can be added using app.Use(...) . Q3. What are Hosting Models in .NET Core? Answer: In-Process hosting – App runs inside IIS worker process ( w3wp.exe ), better perf...
Read more

What are SOLID Principles?

  SOLID is an acronym for five object-oriented design principles that make software more understandable, flexible, and maintainable. 1. S - Single Responsibility Principle (SRP) A class should have only one reason to change. Bad Example (Violating SRP): csharp public class UserService { public void RegisterUser ( string username , string email , string password ) { // Validate user data if ( string . IsNullOrEmpty ( username ) || string . IsNullOrEmpty ( email ) ) throw new ArgumentException ( "Username and email are required" ) ; if ( ! email . Contains ( "@" ) ) throw new ArgumentException ( "Invalid email format" ) ; // Hash password string hashedPassword = BCrypt . Net . BCrypt . HashPassword ( password ) ; // Save to database using ( var connection = new SqlConnection ( "connection_string" ) ) ...
Read more

.NET Core Senior Interview Q&A

  🔹 1. .NET Core Fundamentals Q1. What is the difference between .NET Framework, .NET Core, and .NET 5/6/7? Answer: .NET Framework → Windows-only, monolithic. .NET Core → Cross-platform, modular, open-source. .NET 5/6/7/8 → Unified platform (.NET Core + Mono). Example: In my current project, we migrated from .NET Framework 4.7.2 to .NET 6 for cross-platform support and performance gains (reduced API response time by ~30%).             Windows-only Means the .NET Framework can run only on Windows OS . You cannot directly run .NET Framework apps on Linux or macOS. Monolithic Monolithic application = a single, large, tightly-coupled unit . All layers (UI, business logic, data access) are bundled together and deployed as one package . Even a small change (e.g., fixing a bug in UI) requires rebuilding and redeploying the entire application . Scaling is harder → you must scale the whole app , not just the part th...
Read more